import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import 'storage_service.dart';
import '../api/index.dart';
import '../models/index.dart';
import '../values/constants.dart';

/// 用户服务 - 业务层服务
/// 
/// 🎯 核心职责：
/// - 用户登录/登出业务逻辑
/// - 用户信息管理和验证
/// - 用户权限控制
/// - 用户状态管理
/// - 用户数据持久化
class UserService extends GetxService {
  static UserService get to => Get.find<UserService>();
  
  // ==================== 依赖注入 ====================
  StorageService get _storageService => Get.find<StorageService>();
  
  // ==================== 响应式状态 ====================
  final _isLoggedIn = false.obs;
  final _currentUserProfile = Rxn<UserProfileModel>();
  final _userToken = ''.obs;
  final _refreshToken = ''.obs;
  
  // ==================== 同步访问器 ====================
  bool get isLoggedIn => _isLoggedIn.value;
  UserProfileModel? get currentUserProfile => _currentUserProfile.value;
  String get userToken => _userToken.value;
  String get refreshToken => _refreshToken.value;
  
  // ==================== 响应式访问器 ====================
  RxBool get isLoggedInRx => _isLoggedIn;
  Rxn<UserProfileModel> get currentUserProfileRx => _currentUserProfile;
  RxString get userTokenRx => _userToken;
  RxString get refreshTokenRx => _refreshToken;
  
  // ==================== 权限业务逻辑 ====================
  
  /// 检查用户是否有特定权限（核心业务逻辑）
  bool hasPermission(String permission) {
    final currentProfile = _currentUserProfile.value;
    if (currentProfile?.admin == true) return true;
    // TODO: 实现具体权限检查逻辑
    return false;
  }
  
  /// 检查用户是否有特定角色（核心业务逻辑）
  bool hasRole(String role) {
    final roles = _currentUserProfile.value?.roles?.map((r) => r.roleKey ?? '').toList() ?? [];
    return roles.contains(role);
  }
  
  // ==================== 生命周期 ====================
  @override
  Future<void> onInit() async {
    super.onInit();
    debugPrint('👤 UserService 初始化开始...');
    await _checkLoginStatus();
    debugPrint('✅ UserService 初始化完成');
  }
  
  @override
  void onClose() {
    debugPrint('🧹 UserService 正在清理...');
    super.onClose();
  }
  
  // ==================== 登录相关方法 ====================
  
  /// 用户登录
  Future<LoginResult> login({
    required String username,
    required String password,
  }) async {
    try {
      debugPrint('👤 开始用户登录: $username');
      
      final loginRequest = LoginReq(username: username, password: password);
      final apiResponse = await UserApi.login(loginRequest);
      
      if (!apiResponse.isSuccess || apiResponse.data == null) {
        final errorMessage = apiResponse.errorMessage.isNotEmpty 
            ? apiResponse.errorMessage 
            : '登录失败，请重试';
        debugPrint('❌ API登录失败: $errorMessage');
        return LoginResult.failure(errorMessage);
      }
      
      final tokenModel = apiResponse.data!;
      debugPrint('✅ API登录成功，获取到token');
      
      // 保存基础登录信息
      await _saveBasicLoginInfo(tokenModel, username);
      
      // 尝试获取完整用户信息
      await _fetchAndSaveUserProfile(tokenModel);
      
      debugPrint('✅ 用户登录成功: $username');
      return LoginResult.success();
      
    } catch (e) {
      debugPrint('❌ 用户登录异常: $e');
      return LoginResult.failure('登录过程中发生错误，请重试');
    }
  }
  
  /// 用户退出登录
  Future<bool> logout() async {
    try {
      debugPrint('👤 用户退出登录');
      
      await _clearAllStorageData();
        _clearUserState();
        
        debugPrint('✅ 用户退出登录成功');
        return true;
      
    } catch (e) {
      debugPrint('❌ 用户退出登录失败: $e');
      return false;
    }
  }
  
  /// 刷新访问令牌
  Future<RefreshTokenResult> refreshAccessToken() async {
    try {
      debugPrint('🔄 UserService开始刷新访问令牌');
      
      final currentRefreshToken = _refreshToken.value;
      if (currentRefreshToken.isEmpty) {
        debugPrint('❌ 刷新令牌为空，无法刷新');
        return RefreshTokenResult.failure('刷新令牌不存在');
      }
      
      final apiResponse = await UserApi.refreshToken(currentRefreshToken);
      
      if (!apiResponse.isSuccess || apiResponse.data == null) {
        final errorMessage = apiResponse.errorMessage.isNotEmpty 
            ? apiResponse.errorMessage 
            : '刷新令牌失败，请重新登录';
        
        debugPrint('❌ API刷新令牌失败: $errorMessage');
        
        // 刷新失败可能是刷新令牌过期，自动退出登录
        if (apiResponse.code == Constants.httpStatusUnauthorized) {
          debugPrint('⚠️ 刷新令牌已过期，自动退出登录');
          await logout();
        }
        
        return RefreshTokenResult.failure(errorMessage);
      }
      
      final newTokenModel = apiResponse.data!;
      debugPrint('✅ 令牌刷新成功');
      
      // 更新本地令牌
      await _updateTokens(newTokenModel);
      
      return RefreshTokenResult.success(newTokenModel);
      
    } catch (e) {
      debugPrint('❌ 刷新令牌异常: $e');
      return RefreshTokenResult.failure('刷新令牌过程中发生错误');
    }
  }
  
  // ==================== 用户信息管理 ====================
  
  /// 获取用户个人信息（对外接口）
  /// 
  /// 从服务器获取最新的用户信息并自动保存到本地
  /// 这是标准的服务层方法，供控制器层调用
  /// 会自动检查登录状态，未登录时抛出异常
  Future<UserProfileModel> getUserProfile() async {
    try {
      debugPrint('👤 开始获取用户个人信息');
      
      // ✅ 首先检查登录状态（服务层职责）
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法获取用户信息');
        throw Exception('用户未登录，请先登录');
      }
      
      debugPrint('✅ 用户已登录，继续获取最新用户信息');
      
      // 调用 API 层获取用户信息
      final userProfile = await UserApi.getUserProfile();
      debugPrint('✅ 从服务器获取用户信息成功: ${userProfile.nickName}');
      
      // 自动保存到本地
      await setUserProfile(userProfile);
      debugPrint('✅ 用户信息已保存到本地');
      
      return userProfile;
      
    } catch (e) {
      debugPrint('❌ 获取用户个人信息失败: $e');
      rethrow; // 重新抛出异常，让调用者处理
    }
  }
  
  /// 设置用户信息（核心方法）
  Future<bool> setUserProfile(UserProfileModel userProfile) async {
    try {
      debugPrint('👤 设置用户信息: ${userProfile.nickName}');
      
      // 更新响应式状态
      _currentUserProfile.value = userProfile;
      
      // 保存到本地存储
      await _saveUserProfileToStorage(userProfile);
      
      debugPrint('✅ 用户信息设置成功');
      return true;
        
      } catch (e) {
      debugPrint('❌ 设置用户信息失败: $e');
      return false;
    }
  }
  
  /// 上传并更新用户头像（企业级架构标准化）
  /// 
  /// 🎯 按照6.2规范：立即上传策略
  /// - 用户选择头像 → 立即上传 → 立即更新Service → 立即显示
  /// - Service层统一管理API调用和状态同步
  /// 
  /// [avatarFilePath] 头像文件路径
  /// 返回上传结果，成功时自动更新用户头像信息
  Future<AvatarUploadResult> uploadAndUpdateAvatar(String avatarFilePath) async {
    try {
      debugPrint('👤 Service层：开始上传并更新用户头像');
      
      // ✅ 检查登录状态
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法上传头像');
        return AvatarUploadResult.failure('用户未登录，请先登录');
      }
      
      // 1️⃣ 调用API上传头像
      debugPrint('📤 步骤1: 调用API上传头像文件');
      final uploadResult = await UserApi.uploadAvatar(avatarFilePath);
      
      if (!uploadResult.success || uploadResult.imgUrl == null) {
        debugPrint('❌ 头像上传失败: ${uploadResult.errorMessage}');
        return uploadResult;
      }
      
      debugPrint('✅ 头像上传成功，获得URL: ${uploadResult.imgUrl}');
      
      // 2️⃣ 调用API更新用户信息（更新头像字段）
      debugPrint('📝 步骤2: 调用API更新用户头像信息');
      final request = UpdateUserProfileReq(avatar: uploadResult.imgUrl);
      final updatedProfile = await UserApi.updateUserProfile(request);
      
      debugPrint('✅ API返回更新后的用户信息: ${updatedProfile.nickName}');
      
      // 3️⃣ 更新Service状态（自动触发所有订阅者更新）
      debugPrint('🔄 步骤3: 更新Service响应式状态');
      await setUserProfile(updatedProfile);
      
      debugPrint('✅ Service层：头像上传和更新完成');
      debugPrint('🎉 所有监听此Service的页面将自动同步更新');
      
      return AvatarUploadResult.success(uploadResult.imgUrl!);
      
    } catch (e) {
      debugPrint('❌ Service层：上传头像异常: $e');
      return AvatarUploadResult.failure('头像上传异常：${e.toString()}');
    }
  }
  
  /// 批量更新用户信息（企业级架构标准化）
  /// 
  /// 🎯 按照6.2规范：批量保存策略
  /// - 用户编辑 → 暂存本地 → 点击保存 → 批量上传 → 批量更新Service
  /// - Service层统一管理API调用和状态同步
  /// 
  /// [request] 用户信息更新请求
  /// 返回更新后的用户信息模型，自动保存到本地
  Future<UserProfileModel> updateUserProfile(UpdateUserProfileReq request) async {
    try {
      debugPrint('👤 Service层：开始批量更新用户信息');
      debugPrint('📝 更新请求: ${request.toJson()}');
      
      // ✅ 检查登录状态
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法更新用户信息');
        throw Exception('用户未登录，请先登录');
      }
      
      // 1️⃣ 调用API更新用户信息
      debugPrint('📤 步骤1: 调用API批量更新用户信息');
      final updatedProfile = await UserApi.updateUserProfile(request);
      
      debugPrint('✅ API返回更新后的用户信息: ${updatedProfile.nickName}');
      
      // 2️⃣ 更新Service状态（自动触发所有订阅者更新）
      debugPrint('🔄 步骤2: 更新Service响应式状态');
      await setUserProfile(updatedProfile);
      
      debugPrint('✅ Service层：用户信息批量更新完成');
      debugPrint('🎉 所有监听此Service的页面将自动同步更新');
      
      return updatedProfile;
      
    } catch (e) {
      debugPrint('❌ Service层：更新用户信息异常: $e');
      rethrow; // 重新抛出异常，让调用者处理
    }
  }
  
  // ==================== 数据获取方法 ====================
  

  
  /// 获取最后登录时间
  DateTime? getLastLoginTime() {
    try {
      final timeString = _storageService.getString(Constants.storageKeyLastLoginTime);
      return timeString != null ? DateTime.parse(timeString) : null;
    } catch (e) {
      debugPrint('❌ 获取最后登录时间失败: $e');
      return null;
    }
  }
  
  /// 获取完整的TokenModel
  TokenModel? getTokenModel() {
    try {
      final tokenData = _storageService.getObject(Constants.storageKeyTokenModel);
      return tokenData != null ? TokenModel.fromJson(tokenData) : null;
    } catch (e) {
      debugPrint('❌ 获取TokenModel失败: $e');
      return null;
    }
  }
  
  // ==================== 私有方法 ====================
  
  /// 检查登录状态
  Future<void> _checkLoginStatus() async {
    try {
      final token = _storageService.getString(Constants.storageKeyUserToken) ?? '';
      final refreshToken = _storageService.getString(Constants.storageKeyRefreshToken) ?? '';
      final userProfileData = _storageService.getObject(Constants.storageKeyUserInfo);
      
      if (token.isNotEmpty && userProfileData != null) {
        debugPrint('👤 发现已保存的登录信息');
        
        final userProfile = UserProfileModel.fromJson(userProfileData);
        
        _userToken.value = token;
        _refreshToken.value = refreshToken;
        _currentUserProfile.value = userProfile;
        _isLoggedIn.value = true;
        
        // 检查登录是否过期
        await _checkLoginExpiration();
      } else {
        debugPrint('👤 未找到登录信息');
        _clearUserState();
      }
      
    } catch (e) {
      debugPrint('❌ 检查登录状态失败: $e');
      _clearUserState();
    }
  }
  
  /// 检查登录过期
  Future<void> _checkLoginExpiration() async {
    try {
      final lastLoginTime = getLastLoginTime();
      if (lastLoginTime != null) {
        final daysSinceLogin = DateTime.now().difference(lastLoginTime).inDays;
        if (daysSinceLogin > Constants.loginExpirationDays) {
          debugPrint('⚠️ 登录信息已过期，自动退出登录');
          await logout();
        }
      }
    } catch (e) {
      debugPrint('❌ 检查登录过期失败: $e');
    }
  }
  
  /// 清除用户状态
  void _clearUserState() {
    _isLoggedIn.value = false;
    _currentUserProfile.value = null;
    _userToken.value = '';
    _refreshToken.value = '';
  }
  
  /// 保存基础登录信息
  Future<void> _saveBasicLoginInfo(TokenModel tokenModel, String username) async {
    _userToken.value = tokenModel.accessToken;
    _refreshToken.value = tokenModel.refreshToken;
    _isLoggedIn.value = true;
    
    // 创建基础用户信息
    final basicProfile = UserProfileModel(
      userId: 0,
      userName: username,
      nickName: username,
    );
    _currentUserProfile.value = basicProfile;
    
    // 保存到存储
    await _storageService.setString(Constants.storageKeyUserToken, tokenModel.accessToken);
    await _storageService.setString(Constants.storageKeyRefreshToken, tokenModel.refreshToken);
    await _storageService.setString(Constants.storageKeyUsername, username);
    await _storageService.setString(Constants.storageKeyLastLoginTime, DateTime.now().toIso8601String());
    await _storageService.setObject(Constants.storageKeyTokenModel, tokenModel.toJson());
    
    debugPrint('✅ 基础登录信息保存成功');
  }
  
  /// 获取并保存完整用户信息
  Future<void> _fetchAndSaveUserProfile(TokenModel tokenModel) async {
    try {
      final userProfile = await UserApi.getUserProfile();
      debugPrint('✅ 获取到完整用户信息: ${userProfile.nickName}');
      
      _currentUserProfile.value = userProfile;
      await _saveUserProfileToStorage(userProfile);
      
    } catch (e) {
      debugPrint('⚠️ 获取用户详细信息异常，继续使用基础信息: $e');
    }
  }
  
  /// 保存用户信息到存储
  Future<void> _saveUserProfileToStorage(UserProfileModel userProfile) async {
    final userProfileData = {
      ...userProfile.toJson(),
      'loginTime': DateTime.now().toIso8601String(),
    };
    
    await _storageService.setString(Constants.storageKeyUserId, userProfile.userId.toString());
    await _storageService.setString(Constants.storageKeyUsername, userProfile.userName ?? '');
    await _storageService.setObject(Constants.storageKeyUserInfo, userProfileData);
  }
  
  /// 更新令牌
  Future<void> _updateTokens(TokenModel newTokenModel) async {
    _userToken.value = newTokenModel.accessToken;
    _refreshToken.value = newTokenModel.refreshToken;
    
    await _storageService.setString(Constants.storageKeyUserToken, newTokenModel.accessToken);
    await _storageService.setString(Constants.storageKeyRefreshToken, newTokenModel.refreshToken);
    await _storageService.setObject(Constants.storageKeyTokenModel, newTokenModel.toJson());
    
    debugPrint('✅ 令牌更新成功');
  }
  
  /// 清除所有存储数据
  Future<void> _clearAllStorageData() async {
    final keys = [
      Constants.storageKeyUserToken,
      Constants.storageKeyRefreshToken,
      Constants.storageKeyTokenModel,
      Constants.storageKeyUserId,
      Constants.storageKeyUsername,
      Constants.storageKeyUserInfo,
      Constants.storageKeyLastLoginTime,
    ];
    
    for (final key in keys) {
      await _storageService.remove(key);
    }
    
    debugPrint('✅ 所有存储数据清除成功');
  }
  
}
